package qc.module.platform.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.module.platform.entity.QcUserProject;
import qc.module.platform.repository.QcUserProjectRepository;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * UserProjectService
 *
 * @author QuCheng Tech
 * @create 2023/1/29
 */
@Service
public class UserProjectService {
    private QcUserProjectRepository repository;

    @Autowired
    public void setQcUserProjectRepository(QcUserProjectRepository repository) {
        this.repository = repository;
    }

    /**
     * 判断指定用户是否在指定项目中，返回true表示在项目中，返回false表示不在项目中
     *
     * @param userId      用户ID
     * @param projectCode 项目编码
     * @return boolean
     * @author QuCheng Tech
     * @date 2023/1/29
     */
    public boolean hasExist(Integer userId, String projectCode) {
        if (userId != null && !StringUtils.isBlank(projectCode)) {
            LambdaQueryWrapper<QcUserProject> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(QcUserProject::getUserid, userId);
            wrapper.eq(QcUserProject::getProjectcode, projectCode);

            QcUserProject en = repository.selectOne(wrapper);
            if (en != null)
                return true;
        }

        return false;
    }

    /**
     * 新增用户与项目关联关系，一对一
     *
     * @param userId      用户id
     * @param projectCode 项目编码
     * @return 成功返回null
     * @author QcCheng Tech
     * @since 2023/6/28
     */
    public void add(int userId, String projectCode) {
        if (!StringUtils.isBlank(projectCode) && userId > 0x0) {
            if (!this.hasExist(userId, projectCode)) {
                QcUserProject en = new QcUserProject();
                en.setUserid(userId);
                en.setProjectcode(projectCode);
                repository.insert(en);
            }
        }
    }

    /**
     * 新增用户与项目关联关系，1个项目N个用户
     *
     * @param projectCode 项目编码
     * @param userIds     用户id集合
     * @return 成功返回null
     * @author QcCheng Tech
     * @since 2023/6/28
     */
    public void add(String projectCode, int[] userIds) {
        if (!StringUtils.isBlank(projectCode)) {
            if (userIds != null && userIds.length > 0x0) {
                for (int userId : userIds) {
                    add(userId, projectCode);
                }
            }
        }
    }

    /**
     * 获取指定项目关联的用户id集合
     *
     * @param projectCode 项目编码
     * @return 项目关联用户id集合
     * @author QcCheng Tech
     * @since 2023/6/28
     */
    public List<Integer> getByProjectCode(String projectCode) {
        LambdaQueryWrapper<QcUserProject> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(QcUserProject::getUserid);
        wrapper.eq(QcUserProject::getProjectcode, projectCode);

        List<QcUserProject> ens = repository.selectList(wrapper);

        if (ens != null && ens.size() > 0x0) {
            return ens.stream().map(en -> en.getUserid()).collect(Collectors.toList());
        }
        return null;
    }

    /**
     * 获取指定用户关联的项目编码集合
     *
     * @param userId 用户ID
     * @return 用户关联的项目编码集合
     * @author QcCheng Tech
     * @since 2023/6/28
     */
    public List<String> getByUserId(Integer userId) {
        LambdaQueryWrapper<QcUserProject> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(QcUserProject::getProjectcode);
        wrapper.eq(QcUserProject::getUserid, userId);

        List<QcUserProject> ens = repository.selectList(wrapper);
        if (ens != null && ens.size() > 0x0) {
            return ens.stream().map(QcUserProject::getProjectcode).collect(Collectors.toList());
        }

        return null;
    }

    /**
     * 删除
     *
     * @param userId      用户ID
     * @param projectCode 项目编码
     * @return 成功返回null
     * @author QcCheng Tech
     * @since 2023/6/27
     */
    public void delete(int userId, String projectCode) {
        LambdaUpdateWrapper<QcUserProject> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcUserProject::getUserid, userId);
        wrapper.eq(QcUserProject::getProjectcode, projectCode);
        repository.delete(wrapper);
    }

    /**
     * 删除
     *
     * @param projectCode 项目编码
     * @param userIds     用户ID集合
     * @return 成功返回null
     * @author QcCheng Tech
     * @since 2023/6/27
     */
    public void delete(String projectCode, int[] userIds) {
        //如果传入的类型为int，在此转换为Integer
        Integer ids[] = Arrays.stream(userIds).boxed().toArray(Integer[]::new);

        LambdaUpdateWrapper<QcUserProject> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcUserProject::getProjectcode, projectCode);
        //使用in条件报错，原因为：使用的数据类型需要与实体类定义一致，用户ID的类型需要使用Integer不能使用int
        wrapper.in(QcUserProject::getUserid, ids);
        repository.delete(wrapper);
    }

    /**
     * 删除指定用户关联的所有项目关系
     *
     * @param userId 用户id
     * @return 成功返回null
     * @author QcCheng Tech
     * @since 2023/6/28
     */
    public void deleteByUserId(int userId) {
        LambdaQueryWrapper<QcUserProject> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(QcUserProject::getUserid, userId);
        repository.delete(wrapper);
    }

    /**
     * 按项目编码删除项目关联的所有用户的关联关系
     *
     * @param projectCode 项目编码
     * @author QcCheng Tech
     * @since 2023/6/28
     */
    public void deleteByProjectCode(String projectCode) {
        LambdaQueryWrapper<QcUserProject> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(QcUserProject::getProjectcode, projectCode);
        repository.delete(wrapper);
    }
}
